package wuziqi;

import java.util.Scanner;

public class WuZiQi {

    private static String[][] qiPan;

    public static void main(String[] args) {

        //绘制棋谱
        qiPan = WuZiQi.printBorad();
        Scanner sc = new Scanner(System.in);
        WuZiQi blackPlayer = new WuZiQi();
        WuZiQi whitePlayer = new WuZiQi();
        int blackX = -1;
        int blackY = -1;
        int whiteX = -1;
        int whiteY = -1;
        boolean isRepeat = false;
        for (int i=0;i<qiPan.length;i++) {
            for (int j=0;j<qiPan[0].length;j++) {
                System.out.print(qiPan[i][j]);
            }
            System.out.println();
        }
        System.out.println("欢迎来玩五子棋！");
        System.out.println("现在随机开始白棋先手或者黑棋先手");
        boolean blackState = false;
        boolean whiteState = false;
        int randomShu = (int) (Math.random()*10);
        //表示此时的出手顺序
        boolean flag = false;
        if (randomShu>=5){
            System.out.println("黑棋先手");
            flag = true;
        }else {
            System.out.println("白棋先手");
            flag = false;
        }
        while(true) {
            if (flag) {
                System.out.println("黑棋请输入横轴位置,数字为1到16的整数：");
                blackX = sc.nextInt();
                System.out.println("黑棋横轴位置为：" + blackX);
                System.out.println("黑棋请输入竖轴位置，数字为1到16的整数：");
                blackY = sc.nextInt();
                System.out.println("黑棋竖轴位置为：" + blackY);
                System.out.println("黑球位置为：" + "(" + blackX + "," + blackY + ")");
                while(blackX>16||blackX<1||blackY>16||blackY<1) {
                    System.out.println("黑棋请输入横轴位置,数字为1到16的整数,请不要输错：");
                    blackX = sc.nextInt();
                    System.out.println("黑棋横轴位置为：" + blackX);
                    System.out.println("黑棋请输入竖轴位置，数字为1到16的整数,请不要输错：");
                    blackY = sc.nextInt();
                    System.out.println("黑棋竖轴位置为：" + blackY);
                    System.out.println("黑球位置为：" + "(" + blackX + "," + blackY + ")");
                }
                //判断此位置是否已经放入棋子
                isRepeat = WuZiQi.isRepeat(blackX, blackY);
                while (isRepeat) {
                    System.out.println("请重下,该位置已经被占用！");
                    System.out.println("黑棋请输入横轴位置，数字为1到16的整数：");
                    blackX = sc.nextInt();
                    System.out.println("黑棋横轴位置为：" + blackX);
                    System.out.println("黑棋请输入竖轴位置，数字为1到16的整数：");
                    blackY = sc.nextInt();
                    System.out.println("黑棋竖轴位置为：" + blackY);
                    while(blackX>16||blackX<1||blackY>16||blackY<1) {
                        System.out.println("黑棋请输入横轴位置,数字为1到16的整数,请不要输错：");
                        blackX = sc.nextInt();
                        System.out.println("黑棋横轴位置为：" + blackX);
                        System.out.println("黑棋请输入竖轴位置，数字为1到16的整数,请不要输错：");
                        blackY = sc.nextInt();
                        System.out.println("黑棋竖轴位置为：" + blackY);
                        System.out.println("黑球位置为：" + "(" + blackX + "," + blackY + ")");
                    }
                    System.out.println("黑球位置为：" + "(" + blackX + "," + blackY + ")");
                    //判断此位置是否已经放入棋子
                    isRepeat = WuZiQi.isRepeat(blackX, blackY);
                }
                if (isRepeat == false) {
                    blackPlayer.blackPlay(blackX, blackY, qiPan);
                    for (int i=0;i<qiPan.length;i++){
                        for (int j=0;j<qiPan[0].length;j++){
                            System.out.print(qiPan[i][j]);
                        }
                        System.out.println();
                    }
                    blackState = blackPlayer.isWin(blackX, blackY, qiPan);
                    if (blackState == true) {
                        System.out.println("黑棋胜利");
                        break;
                    }
                    System.out.println("白棋开始下棋");
                    flag = false;
                }
            } else {
                System.out.println("白棋请输入横轴位置，数字为1到16的整数：");
                whiteX = sc.nextInt();
                System.out.println("白棋横轴位置为：" + whiteX);
                System.out.println("白棋请输入竖轴位置，数字为1到16的整数：");
                whiteY = sc.nextInt();
                System.out.println("白棋竖轴位置为：" + whiteY);
                while(whiteX>16||whiteX<1||whiteY>16||whiteY<1) {
                    System.out.println("白棋请输入横轴位置,数字为1到16的整数,请不要输错：");
                    whiteX = sc.nextInt();
                    System.out.println("白棋横轴位置为：" + whiteX);
                    System.out.println("白棋请输入竖轴位置，数字为1到16的整数,请不要输错：");
                    whiteY = sc.nextInt();
                    System.out.println("白棋竖轴位置为：" + whiteY);
                    System.out.println("白球位置为：" + "(" + whiteX + "," + whiteY + ")");
                }
                System.out.println("白球位置为：" + "(" + whiteX + "," + whiteY + ")");
                //判断此位置是否已经放入棋子
                isRepeat = WuZiQi.isRepeat(whiteX, whiteY);
                while (isRepeat) {
                    System.out.println("请重下，该位置已经被占用！");
                    System.out.println("白棋请输入横轴位置，数字为1到16的整数：");
                    whiteX = sc.nextInt();
                    System.out.println("白棋横轴位置为：" + whiteX);
                    System.out.println("白棋请输入竖轴位置，数字为1到16的整数：");
                    whiteY = sc.nextInt();
                    System.out.println("白棋竖轴位置为：" + whiteY);
                    while(whiteX>16||whiteX<1||whiteY>16||whiteY<1) {
                        System.out.println("白棋请输入横轴位置,数字为1到16的整数,请不要输错：");
                        whiteX = sc.nextInt();
                        System.out.println("白棋横轴位置为：" + whiteX);
                        System.out.println("白棋请输入竖轴位置，数字为1到16的整数,请不要输错：");
                        whiteY = sc.nextInt();
                        System.out.println("白棋竖轴位置为：" + whiteY);
                        System.out.println("白球位置为：" + "(" + whiteX + "," + whiteY + ")");
                    }
                    System.out.println("白棋位置为：" + "(" + whiteX + "," + whiteY + ")");

                    //判断此位置是否已经放入棋子
                    isRepeat = WuZiQi.isRepeat(whiteX, whiteY);
                }
                if (isRepeat == false) {
                    whitePlayer.whitePlayer(whiteX, whiteY, qiPan);
                    for (int i=0;i<qiPan.length;i++){
                        for (int j=0;j<qiPan[0].length;j++){
                            System.out.print(qiPan[i][j]);
                        }
                        System.out.println();
                    }
                    whiteState = whitePlayer.isWin(whiteX, whiteY, qiPan);
                    if (whiteState == true) {
                        System.out.println("白棋胜利");
                        break;
                    }
                    System.out.println("黑棋开始下棋");
                    flag = true;
                }
            }
        }
    }

    /*（2）提示黑方和白方分别下棋并重新绘制棋盘 - 写一个成员方法实现。
        提示双方下棋应该是一个循环，在双方未能分出胜负之前，应该要不停
        地对双方进行提醒，例如此时应该由黑方出手，判断，之后由白方
        出手，判断
        出手怎么出手，就是将棋盘中的+号换为各自对应的棋，可以将黑方
        出手的位置设置为-，将白方出手的位置设置为*，出手的位置我们
        应该也在注意，最外面的数字和字母代表棋盘的边界，我们不能在
        此下子，下棋我们需要的参数应该是横纵坐标及棋盘，我们不用
        将棋盘返回，我们只需对棋盘的元素进行修改
    */
    //黑方下棋
    public void blackPlay(int x,int y,String[][] a){
        if (x==0 || y==0) {
            System.out.println("此处为边界，不能在此位置下棋");
        }else if (x>16 || y>16) {
            System.out.println("已经超出边界，不能在此位置下棋");
        }else if(a[x][y]=="*"){
            System.out.println("该位置已被白棋占用！");
            a[x][y]="*";
        }else {
            a[x][y] = "-";
        }
    }
    //白方下棋
    public void whitePlayer(int x,int y,String[][] a){
        if (x==0 || y==0) {
            System.out.println("此处为边界，不能下棋");
        }else if (x>16 || y>16) {
            System.out.println("已经超出边界，不能在此位置下棋");
        }else if(a[x][y]=="-"){
            System.out.println("该位置已被黑棋占用！");
            a[x][y]="-";
        }
        else {
            a[x][y] = "*";
        }
    }

    /*
    *怎么判断输赢就是五子棋的赢法，你可以这么理解
    * 以这个点为中心，总共8个方向，上，右上，右，右下，下，左下，左，左上
    * 以上为例，行数必须大于等于1，小于等于16，设置一个计数器，如果当前
    * 字符与上一个字符相同，则计数器+1，
     */
    public boolean isWin(int x,int y,String[][] a) {
        int rowCount = 1;
        //球的位置向下偏移，选取球的位置向上
        //球的位置从自身算起包含5次
        a:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x + j- i < 17 && x + j - i > 0 && x + j < 17&&x + j> 0){
                    if (a[x + j - i][y] == a[x + j][y])
                    {
                        rowCount++;
                        if ( rowCount == 5){
                            break a;
                        }
                    }else{
                        rowCount = 1;
                        break;
                    }
                } else {
                    rowCount = 1;
                    break;
                }
            }
        }
        //球往上动，选择的位置向下
        //x-j+i
        int rowCount1 = 1;
        b:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x - j + i < 17 && x - j + i > 0 && x - j < 17&&x - j> 0){
                    if (a[x - j + i][y] == a[x - j][y])
                    {
                        rowCount1++;
                        if ( rowCount1 == 5){
                            break b;
                        }
                    }else{
                        rowCount1 = 1;
                        break;
                    }
                } else {
                    rowCount1 = 1;
                    break;
                }
            }
        }
        //向左移动，行不变，列-i
        int colCount = 1;
        c:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (y-j+i < 17 && y-j+i > 0 && y-j < 17&&y-j> 0){
                    if (a[x][y-j+i] == a[x][y-j])
                    {
                        colCount++;
                        if ( colCount == 5){
                            break c;
                        }
                    }else{
                        colCount = 1;
                        break;
                    }
                } else {
                    colCount = 1;
                    break;
                }
            }
        }
        //向右移动，行不变，列+i
        int colCount1 = 1;
        c:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (y+j-i < 17 && y+j-i > 0 && y+j < 17&&y+j> 0){
                    if (a[x][y+j-i] == a[x][y+j])
                    {
                        colCount1++;
                        if ( colCount1 == 5){
                            break c;
                        }
                    }else{
                        colCount1 = 1;
                        break;
                    }
                } else {
                    colCount1 = 1;
                    break;
                }
            }
        }
        //向左上移动，行-i，列-i
        int leftUpCount = 1;
        e:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x-j+i < 17 &&x-j+i >0&& y-j+i > 0&&y-j+i<17 && x-j < 17&&x-j>0&&y-j> 0&&y-j<17){
                    if (a[x-j+i][y-j+i] == a[x-j][y-j])
                    {
                        leftUpCount++;
                        if ( leftUpCount == 5){
                            break e;
                        }
                    }else{
                        leftUpCount = 1;
                        break;
                    }
                } else {
                    leftUpCount = 1;
                    break;
                }
            }
        }
        //向右下移动，行+i，列+i
        int rightDownCount = 1;
        f:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x+j-i < 17 &&x+j-i >0&& y+j-i > 0&&y+j-i<17 && x+j < 17&&x+j>0&&y+j> 0&&y+j<17){
                    if (a[x+j-i][y+j-i] == a[x+j][y+j])
                    {
                        rightDownCount++;
                        if ( rightDownCount == 5){
                            break f;
                        }
                    }else{
                        rightDownCount = 1;
                        break;
                    }
                } else {
                    rightDownCount = 1;
                    break;
                }
            }
        }
        //向左下移动，行+i，列-i
        int leftDownCount = 1;
        g:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x+j-i < 17 &&x+j-i >0&& y-j+i > 0&&y-j+i<17 && x+j < 17&&x+j>0&&y-j> 0&&y-j<17){
                    if (a[x+j-i][y-j+i] == a[x+j][y-j])
                    {
                        leftDownCount++;
                        if ( leftDownCount == 5){
                            break g;
                        }
                    }else{
                        leftDownCount = 1;
                        break;
                    }
                } else {
                    leftDownCount = 1;
                    break;
                }
            }
        }
        //向右上移动，行-i，列+i
        int rigntUpCount = 1;
        h:for ( int j = 0 ; j < 5 ; j++) {
            //比较次数
            for ( int i = 1; i < 5 ; i++) {
                //边界
                if (x-j+i < 17 &&x-j+i >0&& y+j-i > 0&&y+j-i<17 && x-j < 17&&x-j>0&&y+j> 0&&y+j<17){
                    if (a[x-j+i][y+j-i] == a[x-j][y+j])
                    {
                        rigntUpCount++;
                        if ( rigntUpCount == 5){
                            break h;
                        }
                    }else{
                        rigntUpCount = 1;
                        break;
                    }
                } else {
                    rigntUpCount = 1;
                    break;
                }
            }
        }
        return (rowCount>=5||rowCount1>=5||rightDownCount>=5||rigntUpCount>=5||colCount>=5||colCount1>=5||leftDownCount>=5||leftUpCount>=5)?true:false;
    }

    //绘制棋谱
    public static String[][]  printBorad(){
        String[][] qiPan = new String[17][17];
        for(int i=0;i<qiPan.length;i++){
            for (int j=0;j<qiPan[0].length;j++) {
                qiPan[i][j] = "+";
            }
        }
        for(int i=0;i<qiPan.length;i++){
            if (i==0){
                qiPan[i][0]=" ";
            }else if(i>=1&&i<=10) {
                qiPan[i][0] = ("" + (i-1));
            }else {
                qiPan[i][0]=(char)(i+86)+"";
            }
        }
        for (int i=0;i<qiPan[0].length;i++){
            if (i==0){
                qiPan[0][i]=" ";
            }else if (i>=1&&i<=10){
                qiPan[0][i] = ("" + (i-1));
            }else {
                qiPan[0][i] = (char)(i+86)+"";
            }
        }
        return qiPan;

    }

    public static boolean isRepeat(int x,int y) {
        if (qiPan[x][y]=="-"||qiPan[x][y]=="*") {
            return true;
        }
        return false;
    }

    public boolean isTrue(int x,int y){
        if (x==0 || y==0) {
            System.out.println("此处为边界，不能在此位置下棋");
            return false;
        }else if (x>16 || y>16) {
            System.out.println("已经超出边界，不能在此位置下棋");
            return false;
        }
        return true;
    }
}
